export const 找label = (源arr, 关键词或组) => {
	if (Array.isArray(关键词或组)) {
		return 关键词或组.map(关键词 => {
			return 找label单个(源arr, 关键词)
		})
	}
	return 找label单个(源arr, 关键词或组)
}

const 找label单个 = (源arr, 关键词) => {
	// console.log(`找label单个 源arr 👉`,源arr)
	// console.log(`关键词 👉`,关键词)
	const res = 源arr && 源arr.find(item => item.value === 关键词)
	return res?.label
}

export function 添加非重复元素(arr, item) {
	let index = arr.indexOf(item);
	if (index == -1) {
		arr.push(item)
	}
}

export function 取最末元素(req) {
	if (!Array.isArray(req)) return req;
	const res = req.at(-1);
	return res;
}

export function 转tree(data, idKey = 'id', parentKey = '父级id') {
	// 创建一个以 id 为键的对象，用于快速访问  
	const idMap = {};
	data.forEach(item => {
		idMap[item[idKey]] = { ...item, children: [] }; // 初始化每个节点的 children 数组  
	});
	// console.log(`idMap 👉`,idMap)
	const tree = [];

	data.forEach(item => {
		// console.log(`item 👉`,item)
		if (item[parentKey] === null) {
			// 如果没有父级，说明是根节点  
			tree.push(idMap[item[idKey]]);
		} else if (idMap[item[parentKey]]) {
			// 如果有父级，添加到其父级的 children 数组  
			idMap[item[parentKey]].children.push(idMap[item[idKey]]);
		}
	});

	return tree;
}

export function 数组差集(array1, array2) {
	const res = array1.filter(item => !array2.includes(item));
	return res
}

export function 数组交集(array1, array2) {
	const 交集 = array1.filter(item => array2.includes(item));
	return 交集
}
export function 是否有某个以字符结尾(arr, 关键词) {
	return arr.some(item => {
		return item.endsWith(String(关键词));
	});
}

export function 删除元素(arr, 关键词或元素, 字段 = "id") {
	let index = arr.findIndex(item => item?.[字段] === 关键词或元素);
	if (index == -1) {
		index = arr.indexOf(关键词或元素);
	}
	if (index !== -1) {
		arr.splice(index, 1);
	}
}

export function 数组属性排序(arr, 字段 = "id", 倒序 = false) {
	// 会直接修改原数据
	// console.log('数组属性排序ing 字段: ', 字段);
	// console.log('排序前 arr: ', arr);
	arr.sort((a, b) => {
		// 下面漏了return 就等于白干了
		// console.log('a[字段]: ', a[字段]);
		// console.log('b[字段]: ', b[字段]);
		let 比较结果 = a[字段] - b[字段]
		if (typeof a[字段] === 'string') {
			比较结果 = a[字段].localeCompare(b[字段]);
		}
		// console.log('比较结果: ', 比较结果);
		return 比较结果
	});
	if (倒序) {
		arr.reverse();
	}
	// return arr
}


export const 数组全中 = (arr, 大数组) => {
	return arr.every(item => 大数组.includes(item));
}

export const 清除非中文 = (arr) => {
	const filteredArr = arr.filter(item => /^[\u4e00-\u9fa5]+$/.test(item));
	return filteredArr
}

export function 找子级s(范围arr, 查找id) {
	let 子级s = 范围arr.filter((i) => i.parentId == 查找id)
	return 子级s
}

export function 查元素(arr, 关键词, 字段 = 'id') {
	const item = arr.find((item) => item[字段] === 关键词);
	return item
}

export function 查找元素(arr, 关键词, 字段 = 'id') {
	const item = arr.find((item) => item[字段] === 关键词);
	return item
}

export function 查找元素序号(arr, 关键词, 字段 = 'id') {
	const index = arr.findIndex((item) => item[字段] === 关键词);
	return index
}

export function 数组重予(源数组, 新数组) {
	// 清空
	源数组.length = 0
	if (新数组 && 新数组.length > 0) {
		源数组.push(...新数组)
	}
}
export function 按给定数组顺序排序(arr, 排序数组, 字段 = "玩法") {
	arr.sort((a, b) => {
		return 排序数组.indexOf(a[字段]) - 排序数组.indexOf(b[字段]);
	});
}

export const 数组元素转对象 = (arr) => {
	return arr.map((item, index) => {
		const obj = {}
		obj.value = item
		obj.text = item
		return obj
	})
}

export const 数组中取属性组 = (arr, 字段) => {
	if (!arr) return
	const result = [...new Set(arr.map(item => item[字段]))];
	return result;
}

export const 数组过滤 = (范围, 字段, 关键词, 包含关系 = false) => {
	let s = []
	if (!包含关系) {
		s = 范围.filter((i) => i[字段] == 关键词)
	} else {
		s = 范围.filter((i) => {
			// console.log('关键词: ', 关键词);
			// console.log('字段: ', 字段);
			// console.log('i[字段]: ', i[字段]);
			return String(i[字段]).includes(关键词)
		})
	}
	return s
}

export const 数组过滤一排除 = (范围, 字段, 关键词, 包含关系 = false) => {
	let res
	if (!包含关系) {
		res = 范围.filter((i) => i[字段] != 关键词)
	} else {
		res = 范围.filter((i) => !String(i[字段]).includes(关键词))
	}
	return res
}